/**
 * 研发流程状态机使用示例
 * 展示如何在研发项目管理中使用状态机
 */

// 引入状态机
const {
  PROJECT_STATUS,
  ACTIVE_STATE,
  SUB_STATE,
  STATE_EVENTS,
  researchStateMachineStore
} = require('../state_machine');

// 引入辅助工具
const cloudHelper = require('../config/path_resolver').getRootConfigPath('path_resolver.js').getRootConfigPath('path_resolver.js').getRootConfigPath('project_helpers_config.js').(_, __, helper) => helper.replace('.js', '');
const pageHelper = require('../config/path_resolver').getRootConfigPath('path_resolver.js').getRootConfigPath('path_resolver.js').getRootConfigPath('project_helpers_config.js').(_, __, helper) => helper.replace('.js', '');

/**
 * 状态机使用示例类
 * 可以在页面中引入此类，并实例化来使用状态机
 */
class StateMachineExample {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   */
  constructor(page) {
    this.page = page;
    this.store = researchStateMachineStore;
  }
  
  /**
   * 初始化状态机
   * @param {Object} project - 项目数据
   * @param {String} userRole - 当前用户角色
   */
  init(project, userRole) {
    if (!project) {
      console.error('初始化状态机失败：项目数据为空');
      return;
    }
    
    // 设置项目数据
    this.store.setProject(project);
    
    // 设置用户角色
    this.store.setCurrentRole(userRole);
    
    // 加载项目流程历史（可选）
    if (project._id) {
      this.loadFlowHistory(project._id);
    }
    
    console.log('状态机初始化完成:', {
      项目: project.RESEARCH_NAME,
      状态: this.store.getStatusName(project.RESEARCH_STATUS),
      子状态: project.RESEARCH_SUB_STATUS || '',
      活动状态: this.store.getActiveStateName(project.RESEARCH_ACTIVE_STATE),
      角色: userRole
    });
  }
  
  /**
   * 加载项目流程历史
   * @param {String} projectId - 项目ID
   */
  async loadFlowHistory(projectId) {
    try {
      const history = await this.store.loadFlowHistory(projectId);
      
      // 更新页面数据（如需要）
      if (this.page && this.page.setData) {
        this.page.setData({
          flowHistory: history
        });
      }
      
      return history;
    } catch (error) {
      console.error('加载流程历史失败:', error);
      pageHelper.showErrorToast('加载流程历史失败');
      return [];
    }
  }
  
  /**
   * 获取当前可执行的操作
   * @returns {Array} 可执行操作列表
   */
  getAvailableActions() {
    const events = this.store.availableEvents || [];
    
    // 转换为页面友好的格式
    return events.map(event => ({
      id: event.id,
      name: event.name,
      action: () => this.handleStateTransition(event.id)
    }));
  }
  
  /**
   * 处理状态转换
   * @param {String} eventId - 事件ID
   * @param {Object} formData - 表单数据（可选）
   */
  async handleStateTransition(eventId, formData = {}) {
    const project = this.store.project;
    if (!project || !project._id) {
      pageHelper.showErrorToast('项目数据不完整');
      return;
    }
    
    try {
      // 显示加载提示
      pageHelper.showLoadingToast('处理中');
      
      // 准备状态转换参数
      const params = {
        projectId: project._id,
        eventId: eventId,
        formData: formData
      };
      
      // 执行状态转换
      const result = await this.store.performStateTransition(params);
      
      // 隐藏加载提示
      pageHelper.hideLoadingToast();
      
      // 显示成功提示
      pageHelper.showSuccessToast('操作成功');
      
      // 更新页面数据（如需要）
      if (this.page && this.page.setData) {
        this.page.setData({
          project: result.project,
          flowHistory: this.store.flowHistory
        });
      }
      
      // 返回结果
      return result;
    } catch (error) {
      console.error('状态转换失败:', error);
      pageHelper.hideLoadingToast();
      pageHelper.showErrorToast('操作失败：' + (error.message || '未知错误'));
      return null;
    }
  }
  
  /**
   * 获取当前项目状态描述
   * @returns {String} 状态描述
   */
  getProjectStatusDescription() {
    const project = this.store.project;
    if (!project) return '未知状态';
    
    let desc = this.store.getStatusName(project.RESEARCH_STATUS) || '未知状态';
    
    // 如果是活动状态，添加活动状态描述
    if (project.RESEARCH_STATUS === PROJECT_STATUS.ACTIVE && project.RESEARCH_ACTIVE_STATE) {
      const activeStateName = this.store.getActiveStateName(project.RESEARCH_ACTIVE_STATE);
      desc += ` - ${activeStateName}`;
    }
    
    return desc;
  }
  
  /**
   * 判断当前用户是否有特定事件的权限
   * @param {String} eventId - 事件ID
   * @returns {Boolean} 是否有权限
   */
  hasEventPermission(eventId) {
    const events = this.store.availableEvents || [];
    return events.some(event => event.id === eventId);
  }
  
  /**
   * 获取项目进度
   * @returns {Number} 项目进度（0-100）
   */
  getProjectProgress() {
    const project = this.store.project;
    if (!project) return 0;
    
    // 根据状态估算进度
    const progressMap = {
      [PROJECT_STATUS.PROJECT_REVIEW]: 10,
      [PROJECT_STATUS.DORMANT]: 0
    };
    
    // 活动状态的进度
    const activeStateProgressMap = {
      [ACTIVE_STATE.HARDWARE_CONFIRM]: 20, 
      [ACTIVE_STATE.HARDWARE]: 30,
      [ACTIVE_STATE.DEBUG]: 40,
      [ACTIVE_STATE.DATA_SYNC]: 50,
      [ACTIVE_STATE.TESTING]: 60,
      [ACTIVE_STATE.CUSTOMER_CONFIRM]: 70,
      [ACTIVE_STATE.ORDER_PREPARATION]: 80,
      [ACTIVE_STATE.PRODUCTION]: 90,
      [ACTIVE_STATE.PRODUCT_FEEDBACK]: 95
    };
    
    if (project.RESEARCH_STATUS === PROJECT_STATUS.ACTIVE && project.RESEARCH_ACTIVE_STATE) {
      return activeStateProgressMap[project.RESEARCH_ACTIVE_STATE] || 30;
    }
    
    if (project.RESEARCH_STATUS === PROJECT_STATUS.COMPLETED) {
      return 100;
    }
    
    return progressMap[project.RESEARCH_STATUS] || 0;
  }
}

// 示例代码：在页面中使用状态机
/*
Page({
  data: {
    project: null,
    flowHistory: [],
    availableActions: [],
    loading: true
  },
  
  onLoad(options) {
    // 获取项目ID
    const projectId = options.id;
    
    // 初始化状态机
    this.stateMachine = new StateMachineExample(this);
    
    // 加载项目数据
    this.loadProject(projectId);
  },
  
  async loadProject(projectId) {
    try {
      const project = await cloudHelper.callCloudData('research/get_project', { projectId });
      
      // 获取当前用户角色
      const userInfo = await cloudHelper.callCloudData('user/get_my_info');
      const userRole = userInfo.ROLE || 'visitor';
      
      // 初始化状态机
      this.stateMachine.init(project, userRole);
      
      // 获取可执行操作
      const availableActions = this.stateMachine.getAvailableActions();
      
      // 更新页面数据
      this.setData({
        project: project,
        availableActions: availableActions,
        statusDescription: this.stateMachine.getProjectStatusDescription(),
        progress: this.stateMachine.getProjectProgress(),
        loading: false
      });
    } catch (error) {
      console.error('加载项目数据失败:', error);
      pageHelper.showErrorToast('加载项目数据失败');
      this.setData({ loading: false });
    }
  },
  
  // 操作按钮点击事件
  async handleActionClick(e) {
    const eventId = e.currentTarget.dataset.eventId;
    
    // 根据不同事件可能需要不同的表单数据
    let formData = {};
    
    // 对于特定事件，可能需要先打开表单填写
    if (eventId === STATE_EVENTS.PROJECT_ASSIGN_COMPLETE) {
      // 打开分配表单页面
      wx.navigateTo({
        url: `/pages/assignment/assignment?projectId=${this.data.project._id}&eventId=${eventId}`
      });
      return;
    }
    
    // 直接执行状态转换
    await this.stateMachine.handleStateTransition(eventId, formData);
    
    // 操作完成后刷新页面数据
    this.setData({
      statusDescription: this.stateMachine.getProjectStatusDescription(),
      progress: this.stateMachine.getProjectProgress(),
      availableActions: this.stateMachine.getAvailableActions()
    });
  }
});
*/

// 导出示例类
module.exports = StateMachineExample; 